package com.group5.controller;

import com.group5.dao.*;
import com.group5.pojo.*;
import com.group5.service.AdminService;
import com.group5.service.BooleanToJsonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/admin")
public class AdminController {
    @Autowired
    UserssMapper userssMapper;
    @Autowired
    PlatformMapper platformMapper;

    @Autowired
    DrugInfoMapper drugInfoMapper;
    @Autowired
    DrugTagMapper drugTagMapper;
    @Autowired
    CompanyDrugInformationMapper companyDrugInformationMapper;

    AdminService adminService = new AdminService();
    BooleanToJsonService booleanToJsonService = new BooleanToJsonService();

    /**
     * author: 郝文韬
     * 这个文件已经修改好了boolean的问题
     */

    /**
     * 管理员可以输入查询条件，查询机构。
     * 此处前端给出一个json格式Platform对象,根据oid是否为空,内实现有两种查询方式,但是对外展示封装为同一种
     * 另外我们还在别的函数提供查询oid是否存在的方法,所以不要用这个方法查询oid是否存在.当然你非要用我也拦不住
     * 如果oid非空,直接使用oid精确查询
     * 如果oid不非空,使用
     * 机构角色类型(分别有三个,每个都使用整数)
     * 机构名称(String,部分匹配)
     * 机构助记码(String,前匹配)
     * 机构状态(bool)有效/无效,不输入则默认有效
     *
     * @param platform
     * @return 查询列表
     */
    @PostMapping("/query")
    public List<Platform> QueryPlatform(@RequestBody Platform platform) {
        if (platform.getOid() != null)
            return platformMapper.selectByExample(adminService.selectPlatformByPlatformExample(platform));
        return platformMapper.selectPlatformLike(platform);
    }


    //yby--
    @GetMapping("/state")
    //卖方注册成功返回1
    //买方注册成功返回2
    //厂商注册成功返回3
    //卖方注册成功返回4
    //卖方买方注册成功返回5
    //买方厂商注册成功返回6
    //卖方买方厂商注册成功返回7
    //注册失败返回0
    public int ApprovalSellerStatusProcess(@RequestParam String oname,@RequestParam int condition){
        List<Platform> platform = platformMapper.selectByExample(adminService.SelectPlatformeByName(oname));
        if(platform.get(0).getBuyer_state().equals(condition)&&platform.get(0).getSeller_state().equals(condition)&&platform.get(0).getManufacturer_state().equals(condition)){
            platform.get(0).setSeller_state(4);
            platform.get(0).setBuyer_state(4);
            platform.get(0).setManufacturer_state(4);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 7;
        } else if(platform.get(0).getBuyer_state().equals(condition)&&!platform.get(0).getSeller_state().equals(condition)&&platform.get(0).getManufacturer_state().equals(condition)){
            platform.get(0).setSeller_state(3);
            platform.get(0).setBuyer_state(4);
            platform.get(0).setManufacturer_state(4);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 6;
        } else if(platform.get(0).getBuyer_state().equals(condition)&&platform.get(0).getSeller_state().equals(condition)&&!platform.get(0).getManufacturer_state().equals(condition)){
            platform.get(0).setSeller_state(4);
            platform.get(0).setBuyer_state(4);
            platform.get(0).setManufacturer_state(3);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 5;
        } else if(!platform.get(0).getBuyer_state().equals(condition)&&platform.get(0).getSeller_state().equals(condition)&&platform.get(0).getManufacturer_state().equals(condition)){
            platform.get(0).setSeller_state(4);
            platform.get(0).setBuyer_state(3);
            platform.get(0).setManufacturer_state(4);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 4;
        } else if(!platform.get(0).getBuyer_state().equals(condition)&&!platform.get(0).getSeller_state().equals(condition)&&platform.get(0).getManufacturer_state().equals(condition)){
            platform.get(0).setSeller_state(3);
            platform.get(0).setBuyer_state(3);
            platform.get(0).setManufacturer_state(4);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 3;
        }else if(platform.get(0).getBuyer_state().equals(condition)&&!platform.get(0).getSeller_state().equals(condition)&&!platform.get(0).getManufacturer_state().equals(condition)){
            platform.get(0).setSeller_state(3);
            platform.get(0).setBuyer_state(4);
            platform.get(0).setManufacturer_state(3);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 2;
        }else if(!platform.get(0).getBuyer_state().equals(condition)&&platform.get(0).getSeller_state().equals(condition)&&!platform.get(0).getManufacturer_state().equals(condition)){
            platform.get(0).setSeller_state(4);
            platform.get(0).setBuyer_state(3);
            platform.get(0).setManufacturer_state(3);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 1;
        }else {
            platform.get(0).setSeller_state(3);
            platform.get(0).setBuyer_state(3);
            platform.get(0).setManufacturer_state(3);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 0;
        }

    }


    @GetMapping("/role")
    //卖方角色返回1
    //买方角色返回2
    //厂商角色返回3
    //卖方厂商返回4
    //卖方买方角色返回5
    //买方厂商角色返回6
    //卖方买方厂商角色返回7
    //无角色返回0
    public int ManagePlatformRole(@RequestParam String oname){
        List<Platform> platform =platformMapper.selectByExample(adminService.SelectPlatformeByName(oname));
        if(platform.get(0).getSeller_state().equals(4)&&!platform.get(0).getBuyer_state().equals(4)&&!platform.get(0).getManufacturer_state().equals(4)){
            platform.get(0).setOrole_type(1);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 1;
        } else if (!platform.get(0).getSeller_state().equals(4) && platform.get(0).getBuyer_state().equals(4) && !platform.get(0).getManufacturer_state().equals(4)) {
            platform.get(0).setOrole_type(2);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 2;
        } else if(!platform.get(0).getSeller_state().equals(4)&&!platform.get(0).getBuyer_state().equals(4)&&platform.get(0).getManufacturer_state().equals(4)){
            platform.get(0).setOrole_type(3);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 3;
        } else if(platform.get(0).getSeller_state().equals(4)&&!platform.get(0).getBuyer_state().equals(4)&&platform.get(0).getManufacturer_state().equals(4)){
            platform.get(0).setOrole_type(4);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 4;
        } else if(platform.get(0).getSeller_state().equals(4)&&platform.get(0).getBuyer_state().equals(4)&&!platform.get(0).getManufacturer_state().equals(4)){
            platform.get(0).setOrole_type(5);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 5;
        } else if(!platform.get(0).getSeller_state().equals(4)&&platform.get(0).getBuyer_state().equals(4)&&platform.get(0).getManufacturer_state().equals(4)){
            platform.get(0).setOrole_type(6);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 6;
        } else if(platform.get(0).getSeller_state().equals(4)&&platform.get(0).getBuyer_state().equals(4)&&platform.get(0).getManufacturer_state().equals(4)){
            platform.get(0).setOrole_type(7);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 7;
        } else{
            platform.get(0).setOrole_type(0);
            platformMapper.updateByPrimaryKey(platform.get(0));
            return 0;}
    }

    //--yby


    /**
     * 在url中查询指定oid是否存在
     * 举例: 查询10000005  http://172.19.31.82:8080/admin/ifoidexist/10000005
     * @param oid
     * @return BooleanToJsonService ture 表示oid不存在,
     *         booleanToJsonService false; 表示oid存在.
     */
    @GetMapping("/ifoidexist")
    public BooleanToJsonService ifOidExist(@RequestParam Integer oid){
        booleanToJsonService.setCheck( null != platformMapper.selectByPrimaryKey(oid) );
        return booleanToJsonService;
    }

    /**
     * 管理员更新平台机构信息,必须在json中提供oid以唯一确定平台机构
     * 由于用的是selective方法,所以不需要改的都不用写在json里面
     *      例如:修改 oid 为 10000001 平台的名字为 改名测试
     *      {
     *          "oid": 10000001,
     *          "oname": "改名测试"
     *      }
     * 虽然说是更新操作,实际上很多需求都用这同一个就可以了
     *     恢复或禁止,需要update ostate 为true或false
     *     逻辑删除,需要update orole_type 为 8
     *     需求文档里面没说删除以后还要恢复,不知道写文档的沙雕怎么想的,那我们就先不考虑恢复了
     *
     * @param platform
     * @return BooleanToJsonService true表示成功
     *         BooleanToJsonService false表示失败
     *
     */
    @PostMapping("/update")
    public BooleanToJsonService UpdatePlatformSelective(@RequestBody Platform platform){
//        if(platform.getOid()==null){
//            System.out.println("json 中oid不可为空");
//            booleanToJsonService.setCheck(false);
//            return booleanToJsonService;
//        }
        System.out.println(platform);
        if(!ifOidExist(platform.getOid()).isCheck()) {
            System.out.println("oid不存在,先用http://172.19.31.82:8080/admin/ifoidexist/10000005 查询一下再改啊");
            booleanToJsonService.setCheck(false);
            return booleanToJsonService;
        }
        booleanToJsonService.setCheck(1==platformMapper.updateByPrimaryKeySelective(platform));//更新一行说明成功
        return booleanToJsonService;
    }
    /**
     * 获取所有药品信息，包括未审核、逻辑删除
     *
     * @return 所有药品的json
     */

    @GetMapping("/drugs")
    @ResponseBody
    public List<DrugInfo> AllDrugs() {
        return drugInfoMapper.selectByExample(adminService.AllDrugsExample());
//        return JSON.toJSONString(drugInfoMapper.selectByExample(adminService.AllDrugsExample()));
    }

    /**
     * 平台管理员直接添加药品，不需要审核
     * 需要判断库中是否已有该药品，如果库中有该药品且：
     * 1.药品状态为未审核时：不能加入该药品，提醒管理员审核药品；
     * 2.逻辑删除,未通过：直接将药品状态改为可用,更新时间；
     * 3.可用：提醒管理员已存在该药品
     *
     * @param drugInfo
     * @return
     */

    @PostMapping("/drugs")
    public int InsertDrug(@RequestBody DrugInfo drugInfo) {
        List<DrugInfo> list = drugInfoMapper.selectByExample(adminService.DrugNameManufacturerExample(drugInfo));

        if (!list.isEmpty()) {
            DrugInfo drugInfo1=list.get(0);
            switch (drugInfo1.getState_of_drug()) {
                //2表示未审核，数据库不进行操作，前端提醒管理员在未审核区域进行审核
                case "未审核":
                    return 2;
                case "删除":
                case "未通过":
                    drugInfo1.setIndications(drugInfo.getIndications());
                    drugInfo1.setState_of_drug("审核通过");
                    drugInfo1.setUpdated_date(adminService.getTime());
                    return drugInfoMapper.updateByPrimaryKey(drugInfo1);
                //3表示库中已存在该药品
                case "可用":
                    return 3;
            }
        } else {
            adminService.initDrug(drugInfo);
            return drugInfoMapper.insert(drugInfo);
        }
        return 1;
    }

    /**
     * 修改药品信息
     * 前端传入一个drugInfo对象，必须传drug_id，用于查找药品，其他的参数可选，本函数会对非空的参数进行修改
     *
     * @param drugInfo
     * @return booleanToJsonService
     */

    @PutMapping("/drugs")
    public BooleanToJsonService UpdateDrug(@RequestBody DrugInfo drugInfo) {
        drugInfo.setUpdated_date(adminService.getTime());
        booleanToJsonService.setCheck(1 == drugInfoMapper.updateByPrimaryKeySelective(drugInfo));
        return booleanToJsonService;
    }

    /**
     * 逻辑删除药品，将药品状态置为"删除"
     *
     * @param
     * @return booleanToJsonService 成功为true 否则false
     */

    @PutMapping("/drugs/delete")
    public BooleanToJsonService DeleteDrug(@RequestParam int drug_id) {
        DrugInfo drugInfo = drugInfoMapper.selectByPrimaryKey(drug_id);
        adminService.DeleteDrug(drugInfo);
        booleanToJsonService.setCheck(1 == drugInfoMapper.updateByPrimaryKeySelective(drugInfo));
        return booleanToJsonService;
    }

    /**
     * 获取所有待审核的药品，待审核药品由机构管理员申请，需要平台管理员审核通过才能加入到全档药品中
     *
     * @return 所有未审核的药品
     */

    @GetMapping("/drugs/uncheck")
    @ResponseBody
    public List<DrugInfo> AllUnauditedDrug() {
        return drugInfoMapper.selectByExample(adminService.AllUnauditedDrugExample());
    }

    /**
     * 审核药品
     *
     * @param drug_id   前端通过json传入drug_id
     * @param check_code 1表示审核通过，将药品状态改为可用，0表示不通过，将药品状态改为不通过
     * @return
     */

    @PutMapping("/drugs/audit")
    public BooleanToJsonService CheckDrug(@RequestParam int  drug_id, @RequestParam int check_code) {
        DrugInfo drugInfo=drugInfoMapper.selectByPrimaryKey(drug_id);
        adminService.AuditDrugByAuditCode(drugInfo, check_code);
        List<CompanyDrugInformation> companyDrugInformations=companyDrugInformationMapper.selectByExample(adminService.selectCompanyDrugByDrug_id(drug_id));

        adminService.AuditCompanyDrugByAuditCode(companyDrugInformations,check_code);
        booleanToJsonService.setCheck(1 == drugInfoMapper.updateByPrimaryKeySelective(drugInfo));
        return booleanToJsonService;
    }

    /**
     * 初始化药品树，这个方法不需要前端调用，在编码阶段已经加到数据库中。药品树共4层，现在已经将所有的类别初始化完毕，药品如何加入到树中还未考虑。
     * DrugTag的数据结构中，class_name表示类别（药品）名称，class_code表示本类别的编码，class_description未使用，upper_class表示父结点的编码，is_leaf判断是否是药品（1表示药品，0表示类别）
     * 实际使用中，默认根结点为0（没有名字，不存在数据库中，是一个假想的结点），第一层类别的upper_code为0
     * 搜索某一类别下的子结点集的方法是：select * from drug_tag where upper_code=this.class_code(非sql语句)
     */

    @PostMapping("/drugtags")
    public void initDrugTags(){
        List<DrugTag> drugTagList=adminService.initDrugTag();
        for (DrugTag drugTag:drugTagList){
            drugTagMapper.insert(drugTag);
        }
    }


    //数据库type表示需要修改的state类型（卖方或买方或机构），state为卖方\买方\机构状态
    @GetMapping("/platform")
    public Platform isPlatformExist(@RequestParam int oid, @RequestParam int type, @RequestParam int state) {
        List<Platform> platforms = platformMapper.selectByExample(adminService.selectPlatformByOid(oid));
        Platform platformtmp = platforms.get(0);
        platformtmp.setOrole_type(type);
        if (type == 1) {
            platformtmp.setSeller_state(state);
        } else if (type == 2) {
            platformtmp.setBuyer_state(state);
        } else if (type == 3) {
            platformtmp.setManufacturer_state(state);
        } else
            return platformtmp;
        platformMapper.updateByPrimaryKey(platformtmp);
        return platformtmp;
    }

    /**
     *返回机构的所有信息
     */
    @GetMapping("/platforms")
    public List<Platform> AllPlatform(){
        return platformMapper.selectByExample(adminService.AllPlatformExample());
    }

    @GetMapping("/AllApplicablePlatforms")
    public List<Platform> AllApplicablePlatforms(){
        return platformMapper.selectByExample(adminService.AllApplicablePlatformExample());
    }
    /**
     *通过json字符串传递需要修改的信息
     * 可以实现platform的任意表项的修改
     */
    @PutMapping("/platforms")
    public int ManagementPlatform(@RequestParam int uid,@RequestBody Platform platform){
        return platformMapper.updateByPrimaryKey(platform);
    }

    /**
     * 审核用户提出的新建机构申请，前端返回带有审核标志（.*_state为3或4）的机构对象，根据审核结果，对数据库进行更新
     * 3：不通过，只更新机构
     * 4：通过，提出申请的用户变为该机构的管理员，更新机构和用户
     * @param
     * @return
     */
//    {
//        "oid":10000009,
//            "oname": "李铭宇创建的公司",
//            "omnemonics_code": 9999999,
//            "ostate":1,
//            "seller_state": 3,
//            "manufacturer_state":0,
//            "buyer_state":0,
//            "platform_operator":0
//    }
    @PutMapping("/platforms/audit")
    public BooleanToJsonService AuditPlatform(@RequestParam int oid,@RequestParam int check_code) {
        Platform platform=platformMapper.selectByPrimaryKey(oid);
        if (check_code==1) {
            int role_type=adminService.PlatformType(platform);
            platform.setOrole_type(role_type);
            Userss userss = userssMapper.selectByExample(adminService.selectUserByOidExample(platform.getOid())).get(0);
            userss.setIs_organization_accept(1);
            userss.setUser_authority(role_type+1);
            userssMapper.updateByPrimaryKey(userss);
        }
        else {
            adminService.unpassPlatform(platform);
            Userss userss= userssMapper.selectByExample(adminService.selectUserByOidExample(platform.getOid())).get(0);
            userss.setOid(null);
            userss.setIs_organization_accept(0);
            userssMapper.updateByPrimaryKey(userss);
        }
        booleanToJsonService.setCheck(1 == platformMapper.updateByPrimaryKeySelective(platform));
        return booleanToJsonService;
    }

    /**

     * user加入已有平台，机构管理员审核阶段
     * 前端返回uid和审核结果，如果state：
     *      true：审核通过，只需要将is_organization_accept改为1（因为在申请时已经将oid和authority设置好了）
     *      false:不通过，这时需要将user回退到未申请的状态，即oid为null，Is_organization_accept=0，authority=1
     */
    @PutMapping("/selectedplatform")
    public BooleanToJsonService reviewUserss(@RequestParam int uid,@RequestParam boolean state)
    {
        System.out.println(state);
        Userss userss=userssMapper.selectByPrimaryKey(uid);
        if(state){
            userss.setIs_organization_accept(1);
        }
        else {
            userss.setOid(0);//改成默认就行
            userss.setUser_authority(1);
        }
        booleanToJsonService.setCheck(1 == userssMapper.updateByPrimaryKeySelective(userss));
        return booleanToJsonService;
    }

    /**
     * 查询某机构所有未审核的用户，这个方法由机构管理员调用，所以传参为机构管理员的username
     *
     * @param username
     * @return
     */

    @GetMapping("/users/unaudited")
    public List<Userss> AllUnauditedUsers(@RequestParam String username){
        Userss userss=userssMapper.selectByExample(adminService.selectUserByUsernameExample(username)).get(0);
        //System.out.println(userss);
        return userssMapper.selectByExample(adminService.selectUserByOidAndAuthorityExample(userss.getOid()));
    }


    /**
     * 由平台管理员调用，获取所有未审核的机构
     * @return 未审核的机构
     */
    @GetMapping("/platforms/unaudited")
    @ResponseBody
    public List<Platform> AllUnauditedPlatforms(){
        return platformMapper.selectByExample(adminService.AllUnauditedPlatformExample());
    }


    /**
     * 更新DrugTag,现在药品不会出现在DrugTag中，条目is_leaf现在会标识该类别是否是类别树的叶子。
     * 药品加入到DrugTag的操作为，直接将drugInfo的class_code设置为要放入的DrugTag的class_code(is_leaf必须为true)
     */

    @PutMapping("/update_drugtags")
    public void updateDrugTags(){
        for(int class_code=1;class_code<=172;class_code++){
            List<DrugTag> drugTagList=drugTagMapper.selectByExample(adminService.selectDrugTagListByUpperClass(class_code));
            if(drugTagList.isEmpty()){
                drugTagMapper.updateByPrimaryKeySelective(new DrugTag(class_code,true));
            }
        }
    }

    /**
     * 获取所有未分组的药品，同时调用AllDrugTagLeaf()，对于一个未分类的药品，前端选取一个类别并确认，即完成了一次药物分类。
     * @return 未分组的药品
     */

    @GetMapping("/drugs/not_classified")
    public List<DrugInfo> AllNotClassifiedDrugs(){
        return drugInfoMapper.selectByExample(adminService.AllNotClassifiedDrugsExample());
    }

    /**
     * 获取所有药品类别树的叶子供前端选择
     * @return 所有的叶子类别
     */

    @GetMapping("/drugtags/leaf")
    public List<DrugTag> AllDrugTagLeaf(){
        return drugTagMapper.selectByExample(adminService.AllDrugTagsLeafExample());
    }

    /**
     * 前端回传药品信息和分类信息，数据库更新后，后端就完成了一次药物分类
     * @param drug_id
     * @param class_code
     * @return booleanToJsonService
     */

    @PutMapping("/drugs/classify")
    public BooleanToJsonService DrugsClassify(@RequestParam int drug_id,@RequestParam int class_code){
        booleanToJsonService.setCheck(1 == drugInfoMapper.updateByPrimaryKeySelective(new DrugInfo(drug_id,class_code)));
        return booleanToJsonService;
    }

    /**
     * 机构管理员添加药品至CompanyDrugInformation,前端传输json字符串
     * 添加后按照Oid_Manufacturer属性在Platfrom中查到对应oname
     * 拿drug_name，查询到的oname与drug_info中的drug_name,manufacturer属性进行比较
     * 如果两个均重复，则直接赋值对应drug_id
     * 否则赋值前端输入的drug_id并改corresponding_state为“申请状态”
     * 同时在全档药品DrugInfo中添加该药品信息，等待全档药品管理员审核
     * @param companyDrugInformation
     * return 1
     */

    @PostMapping("/companydrug")
    public BooleanToJsonService addCompany_Drug(@RequestBody CompanyDrugInformation companyDrugInformation){
        int oid_manufacturer = companyDrugInformation.getOid_manufacturer();
        String drug_name = companyDrugInformation.getDrug_name();                               //药品name比较的属性之一
        Platform platform = platformMapper.selectByPrimaryKey(oid_manufacturer);
        if (platform == null) {
            booleanToJsonService.setCheck(0==1);
            return booleanToJsonService;
        }
        String oname = platform.getOname();          //查询制造者的oname,比较的属性之一
        DrugInfo blurdrugInfo = new DrugInfo();
        blurdrugInfo.setDrug_name(drug_name);
        blurdrugInfo.setManufacturer(oname);
        DrugInfo drugInfo = drugInfoMapper.blurselectDrugInfo(blurdrugInfo);                    //blur查询全档药品信息
        if(drugInfo==null) {
            companyDrugInformation.setState_of_drug("申请状态");
            drugInfo=new DrugInfo(drug_name,oname,"无","2099-12-31 23:59:59",adminService.getTime(),adminService.getTime(),
                    "未审核",companyDrugInformation.getCorresponding_state(),-1);
            drugInfoMapper.insertSelective(drugInfo);
        }
        else if(drugInfo.getState_of_drug().equals("未审核")){
            companyDrugInformation.setState_of_drug("申请状态");
        }
        else
            companyDrugInformation.setState_of_drug("审核通过");
        drugInfo=drugInfoMapper.blurselectDrugInfo(drugInfo);
        companyDrugInformation.setDrug_id(drugInfo.getDrug_id());
        companyDrugInformation.setUpdate_date(adminService.getTime());
        companyDrugInformation.setCreation_date(adminService.getTime());
//        companyDrugInformation.setState_of_drug("申请状态");
        CompanyDrugInformation companyDrugInformationtmp = companyDrugInformationMapper.blurselectCompanyDrug(companyDrugInformation);
        if (companyDrugInformationtmp==null)
            booleanToJsonService.setCheck(1==companyDrugInformationMapper.insertSelective(companyDrugInformation));
        else {
            companyDrugInformation.setEnterprise_drug_code(companyDrugInformationtmp.getEnterprise_drug_code());
            booleanToJsonService.setCheck(1 == companyDrugInformationMapper.updateByPrimaryKeySelective(companyDrugInformation));
        }return booleanToJsonService;
    }

    /**
     * 全档药品管理员审核全档药品，改变drug_info和company_drug_info两个表中的数据状态
     * 前端传递待审核药品drug_id
     * 后端同时修改两个表中的状态为可用和通过
     * @param drugid
     * return
     */
    @PutMapping("/drugcheck")
    public BooleanToJsonService checkDrug(@RequestParam int drugid) {
        DrugInfo drugInfo = drugInfoMapper.selectByPrimaryKey(drugid);
        if (drugInfo==null) {
            booleanToJsonService.setCheck(0==1);
            return booleanToJsonService;
        }
        drugInfo.setUpdated_date(adminService.getTime());
        drugInfo.setState_of_drug("审核通过");
        drugInfoMapper.updateByPrimaryKeySelective(drugInfo);
        CompanyDrugInformation companyDrugInformation = new CompanyDrugInformation();
        companyDrugInformation.setDrug_name(drugInfo.getDrug_name());
        companyDrugInformation.setDrug_id(drugid);
        companyDrugInformation = companyDrugInformationMapper.blurselectCompanyDrug(companyDrugInformation);
        companyDrugInformation.setState_of_drug("审核通过");
        booleanToJsonService.setCheck(1==companyDrugInformationMapper.updateByPrimaryKeySelective(companyDrugInformation));
        return booleanToJsonService;
    }

  

    /**
     * 更新CompanyDrug的信息
     * 前端传递完整的CompanyDrugInformation的json信息
     * 后端直接进行updateselect更新
     * @param companyDrugInformation
     * @return
     */
    @PutMapping("/companydrug/update")
    public int updateCompanydrug(@RequestBody CompanyDrugInformation companyDrugInformation){
        adminService.updateCompanyDrugInfoTime(companyDrugInformation);
        return companyDrugInformationMapper.updateByPrimaryKeySelective(companyDrugInformation);
    }

    /**
     * 查找uid对应的卖方人员所在oid下的所有companydrug信息
     * 前端传递uid
     * 先在userss中查找对应oid
     * 然后在companydrug中查找返回所有满足oid==oid_seller的信息
     * @param username
     * @return
     */
    @GetMapping("/companydrug")
    public List<CompanyDrugInformation> selectCompanydrugByoid(@RequestParam String username)
    {
        Userss userss = userssMapper.selectByExample(adminService.selectUserByUsernameExample(username)).get(0);
        if(userss==null)
            return null;
        int oid = userss.getOid();
        return companyDrugInformationMapper.selectAllByOid_seller(oid);
    }


    /**
     * 物理删除卖方药品信息，由卖方管理员调用，向后端传参数为公司药品编码，数据库直接删除掉这个条目
     * @param enterprise_drug_code
     * @return
     */
    @DeleteMapping("/Companydrug")
    public int DeleteCompanyDrugByEnterprise_drug_code(@RequestParam int enterprise_drug_code){
        return companyDrugInformationMapper.deleteByPrimaryKey(enterprise_drug_code);
    }


    /**
     * 查询机构用户信息，由机构管理员调用，向前端发送该机构所有用户的信息，现在的逻辑是只有审核通过的用户才可以发送
     *      传参数为机构管理员的uid，String型，需要先转化为Integer然后查到对应的管理员，根据管理员的oid查到该机构的用户
     * @param username
     * @return
     */

    @GetMapping("/users")
    public List<Userss> selectUserByPlatformAdmin(@RequestParam String username){
        Userss userss=userssMapper.selectByExample(adminService.selectUserByUsernameExample(username)).get(0);
        return userssMapper.selectByExample(adminService.selectUserByOidAndAuthorityAndIs_organization_acceptExample(userss.getOid()));
    }

    /**
     * 修改用户信息，由机构管理员调用
     * TODO：现在机构管理员可以修改用户名等数据，但是判断重名的限制还没有加,管理员修改自己的用户名会报错
     * @param userss
     * @return
     */

    @PutMapping("/users")
    public int updateUser(@RequestBody Userss userss){
        return userssMapper.updateByPrimaryKeySelective(userss);

    }


}
